/**
 * 工作流 API 服务层
 * 用于管理 yunjian_worklFlow 目录中的各种工作流
 */

import { lightCCApi, type TaskProgressResponse, type TaskResultResponse } from './lightcc-api'

// 工作流类型定义
export type WorkflowType = 
  | 'spa-text'           // SPA生图（手写提示词）
  | 'spa-style'          // SPA生图（风格参考）
  | 'light-modify'       // 光线修改
  | 'single-edit'        // 单图指令编辑
  | 'double-edit'        // 双图编辑参考风格
  | 'billiards-text'     // 台球生图（手写提示词）
  | 'billiards-style'    // 台球生图（风格参考）
  | 'image-to-video'     // 图生视频
  | 'inpainting'         // 局部重绘
  | 'yoga-text'          // 瑜伽生图（手写提示词）
  | 'yoga-style'         // 瑜伽生图（风格参考）
  | 'migration'          // 迁移
  | 'upscale-gemini'     // 高清放大（gemini）

// 工作流参数接口
export interface WorkflowParams {
  // 通用参数
  prompt?: string
  negativePrompt?: string
  width?: number
  height?: number
  steps?: number
  cfg?: number
  seed?: number
  
  // 图片相关参数
  inputImage?: File
  styleImage?: File
  maskImage?: File
  
  // 视频相关参数
  videoLength?: number
  fps?: number
  
  // 其他参数
  [key: string]: any
}

// 工作流配置
interface WorkflowConfig {
  name: string
  description: string
  filePath: string
  requiredParams: string[]
  optionalParams: string[]
}

// 工作流配置映射
const WORKFLOW_CONFIGS: Record<WorkflowType, WorkflowConfig> = {
  'spa-text': {
    name: 'SPA生图（手写提示词）',
    description: '基于文本提示词生成SPA场景图片',
    filePath: '/yunjian_worklFlow/SPA生图（手写提示词）API.json',
    requiredParams: ['prompt'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'spa-style': {
    name: 'SPA生图（风格参考）',
    description: '基于风格参考图片生成SPA场景',
    filePath: '/yunjian_worklFlow/SPA生图（风格参考）API.json',
    requiredParams: ['prompt', 'styleImage'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'light-modify': {
    name: '光线修改',
    description: '修改图片的光线效果',
    filePath: '/yunjian_worklFlow/光线修改API.json',
    requiredParams: ['inputImage'],
    optionalParams: ['prompt', 'intensity', 'temperature', 'contrast']
  },
  'single-edit': {
    name: '单图指令编辑',
    description: '基于指令对单张图片进行编辑',
    filePath: '/yunjian_worklFlow/单图指令编辑API.json',
    requiredParams: ['inputImage', 'prompt'],
    optionalParams: ['negativePrompt', 'strength', 'steps', 'cfg']
  },
  'double-edit': {
    name: '双图编辑参考风格',
    description: '使用参考图片的风格编辑目标图片',
    filePath: '/yunjian_worklFlow/双图编辑参考风格API.json',
    requiredParams: ['inputImage', 'styleImage', 'prompt'],
    optionalParams: ['negativePrompt', 'styleStrength', 'steps', 'cfg']
  },
  'billiards-text': {
    name: '台球生图（手写提示词）',
    description: '基于文本提示词生成台球场景图片',
    filePath: '/yunjian_worklFlow/台球生图（手写提示词）API.json',
    requiredParams: ['prompt'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'billiards-style': {
    name: '台球生图（风格参考）',
    description: '基于风格参考图片生成台球场景',
    filePath: '/yunjian_worklFlow/台球生图（风格参考）API.json',
    requiredParams: ['prompt', 'styleImage'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'image-to-video': {
    name: '图生视频',
    description: '将图片转换为视频',
    filePath: '/yunjian_worklFlow/图生视频API.json',
    requiredParams: ['inputImage'],
    optionalParams: ['prompt', 'videoLength', 'fps', 'motionStrength']
  },
  'inpainting': {
    name: '局部重绘',
    description: '对图片的局部区域进行重绘',
    filePath: '/yunjian_worklFlow/局部重绘API.json',
    requiredParams: ['inputImage', 'maskImage', 'prompt'],
    optionalParams: ['negativePrompt', 'strength', 'steps', 'cfg']
  },
  'yoga-text': {
    name: '瑜伽生图（手写提示词）',
    description: '基于文本提示词生成瑜伽场景图片',
    filePath: '/yunjian_worklFlow/瑜伽生图（手写提示词）API.json',
    requiredParams: ['prompt'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'yoga-style': {
    name: '瑜伽生图（风格参考）',
    description: '基于风格参考图片生成瑜伽场景',
    filePath: '/yunjian_worklFlow/瑜伽生图（风格参考）API.json',
    requiredParams: ['prompt', 'styleImage'],
    optionalParams: ['negativePrompt', 'width', 'height', 'steps', 'cfg', 'seed']
  },
  'migration': {
    name: '迁移',
    description: '图片风格迁移',
    filePath: '/yunjian_worklFlow/迁移API.json',
    requiredParams: ['inputImage', 'styleImage'],
    optionalParams: ['prompt', 'styleStrength', 'steps', 'cfg']
  },
  'upscale-gemini': {
    name: '高清放大（gemini）',
    description: '使用Gemini模型对图片进行高清放大',
    filePath: '/yunjian_worklFlow/高清放大（gemini）API.json',
    requiredParams: ['inputImage'],
    optionalParams: ['scaleFactor', 'modelName']
  }
}

export class WorkflowApiService {
  /**
   * 获取工作流配置
   */
  getWorkflowConfig(type: WorkflowType): WorkflowConfig {
    return WORKFLOW_CONFIGS[type]
  }

  /**
   * 获取所有可用的工作流类型
   */
  getAvailableWorkflows(): WorkflowType[] {
    return Object.keys(WORKFLOW_CONFIGS) as WorkflowType[]
  }

  /**
   * 加载工作流JSON文件
   */
  async loadWorkflow(type: WorkflowType): Promise<any> {
    const config = this.getWorkflowConfig(type)
    try {
      const response = await fetch(config.filePath)
      if (!response.ok) {
        throw new Error(`无法加载工作流文件: ${config.filePath}`)
      }
      return await response.json()
    } catch (error) {
      console.error(`加载工作流失败 (${type}):`, error)
      throw error
    }
  }

  /**
   * 验证工作流参数
   */
  validateParams(type: WorkflowType, params: WorkflowParams): { valid: boolean; errors: string[] } {
    const config = this.getWorkflowConfig(type)
    const errors: string[] = []

    // 调试信息
    console.log('验证工作流参数:', {
      type,
      params,
      requiredParams: config.requiredParams
    });

    // 检查必需参数
    for (const param of config.requiredParams) {
      const value = params[param]
      console.log(`检查参数 ${param}:`, value);
      if (value === undefined || value === null || (typeof value === 'string' && value.trim() === '')) {
        errors.push(`缺少必需参数: ${param}`)
      }
    }

    console.log('参数验证结果:', { valid: errors.length === 0, errors });

    return {
      valid: errors.length === 0,
      errors
    }
  }

  /**
   * 处理图片上传
   */
  async handleImageUpload(file: File): Promise<string> {
    const result = await lightCCApi.uploadImage(file);
    return result.fileName;
  }

  /**
   * 处理多个图片上传
   */
  async handleMultipleImageUpload(files: File[]): Promise<string[]> {
    const uploadPromises = files.map(file => this.handleImageUpload(file))
    return await Promise.all(uploadPromises)
  }

  /**
   * 执行工作流
   */
  async executeWorkflow(
    type: WorkflowType, 
    params: WorkflowParams,
    onProgress?: (progress: TaskProgressResponse) => void
  ): Promise<TaskResultResponse> {
    try {
      // 验证参数
      const validation = this.validateParams(type, params)
      if (!validation.valid) {
        throw new Error(`参数验证失败: ${validation.errors.join(', ')}`)
      }

      // 加载工作流
      const workflow = await this.loadWorkflow(type)
      
      // 处理图片上传
      const imageFiles: string[] = []
      const imagePaths: { [key: string]: string } = {}
      
      if (params.inputImage) {
        const path = await this.handleImageUpload(params.inputImage)
        imageFiles.push(path)
        imagePaths.inputImage = path
      }
      if (params.styleImage) {
        const path = await this.handleImageUpload(params.styleImage)
        imageFiles.push(path)
        imagePaths.styleImage = path
      }
      if (params.maskImage) {
        const path = await this.handleImageUpload(params.maskImage)
        imageFiles.push(path)
        imagePaths.maskImage = path
      }

      // 根据工作流类型处理参数
      const processedWorkflow = this.processWorkflowParams(workflow, type, params, imagePaths)

      // 创建任务
      const createResult = await lightCCApi.createTask(processedWorkflow, imageFiles)
      
      // 轮询任务进度
      return await lightCCApi.pollTaskProgress(createResult.taskId, (progress) => {
        if (onProgress) {
          onProgress(progress)
        }
      })
    } catch (error) {
      console.error(`执行工作流失败 (${type}):`, error)
      throw error
    }
  }

  /**
   * 处理工作流参数（根据不同类型的工作流进行特殊处理）
   */
  private processWorkflowParams(workflow: any, type: WorkflowType, params: WorkflowParams, imagePaths?: { [key: string]: string }): any {
    // 这里需要根据具体的工作流结构来处理参数
    // 由于每个工作流的节点结构不同，这里提供一个通用的处理框架
    
    const processedWorkflow = JSON.parse(JSON.stringify(workflow)) // 深拷贝
    
    // 根据工作流类型进行特殊处理
    switch (type) {
      case 'spa-text':
      case 'billiards-text':
      case 'yoga-text':
        // 文本生图类工作流，需要替换提示词节点
        this.updateTextPromptNodes(processedWorkflow, params.prompt || '', params.negativePrompt || '')
        break
        
      case 'spa-style':
      case 'billiards-style':
      case 'yoga-style':
        // 风格参考类工作流
        this.updateTextPromptNodes(processedWorkflow, params.prompt || '', params.negativePrompt || '')
        this.updateStyleImageNodes(processedWorkflow, imagePaths)
        break
        
      case 'light-modify':
      case 'single-edit':
      case 'double-edit':
      case 'inpainting':
      case 'migration':
        // 图片编辑类工作流
        this.updateImageEditNodes(processedWorkflow, params)
        break
        
      case 'image-to-video':
        // 视频生成类工作流
        this.updateVideoNodes(processedWorkflow, params)
        break
        
      case 'upscale-gemini':
        // 高清放大类工作流
        this.updateUpscaleNodes(processedWorkflow, params)
        break
    }
    
    return processedWorkflow
  }

  /**
   * 更新文本提示词节点
   */
  private updateTextPromptNodes(_workflow: any, prompt: string, negativePrompt: string): void {
    // 查找并更新提示词相关的节点
    // 这里需要根据具体的工作流结构来实现
    console.log('更新文本提示词节点:', { prompt, negativePrompt })
  }

  /**
   * 更新风格图片节点
   */
  private updateStyleImageNodes(workflow: any, imagePaths?: { [key: string]: string }): void {
    // 查找并更新风格图片相关的节点
    console.log('更新风格图片节点', imagePaths)
    
    if (!imagePaths?.styleImage) {
      console.warn('没有找到风格参考图片路径')
      return
    }
    
    // 遍历工作流节点，查找图片加载节点
    for (const nodeId in workflow) {
      const node = workflow[nodeId]
      if (node && typeof node === 'object') {
        // 查找 LoadImage 类型的节点（通常是风格参考图片）
        if (node.class_type === 'LoadImage' && node.inputs) {
          // 检查是否是风格参考图片节点（通常有特定的命名模式）
          if (node.inputs.image && typeof node.inputs.image === 'string') {
            // 将图片路径设置为上传后的路径
            node.inputs.image = imagePaths.styleImage
            console.log('更新风格参考图片节点:', nodeId, '新路径:', imagePaths.styleImage)
          }
        }
      }
    }
  }

  /**
   * 更新图片编辑节点
   */
  private updateImageEditNodes(_workflow: any, params: WorkflowParams): void {
    // 查找并更新图片编辑相关的节点
    console.log('更新图片编辑节点:', params)
  }

  /**
   * 更新视频生成节点
   */
  private updateVideoNodes(_workflow: any, params: WorkflowParams): void {
    // 查找并更新视频生成相关的节点
    console.log('更新视频生成节点:', params)
  }

  /**
   * 更新高清放大节点
   */
  private updateUpscaleNodes(_workflow: any, params: WorkflowParams): void {
    // 查找并更新高清放大相关的节点
    console.log('更新高清放大节点:', params)
  }
}

// 创建单例实例
export const workflowApi = new WorkflowApiService()

